home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 010 / advent.arc / VERB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1984-05-15  |  12.7 KB  |  901 lines
  1.  
  2. /*    program VERB.C                        *\
  3. \*    WARNING: "advent.c" allocates GLOBAL storage space by    *\
  4. \*        including "advdef.h".                *\
  5. \*        All other modules use "advdec.h".        */
  6.  
  7.  
  8. #include    "stdio.h"    /* drv = 1.1st file 2.def 3.A    */
  9. #include    "advent.h"
  10. #include    "advdec.h"
  11.  
  12.  
  13. /*
  14.     Routine to process a transitive verb
  15. */
  16. trverb()
  17. {
  18.     switch(verb){
  19.     case CALM:
  20.     case WALK:
  21.     case QUIT:
  22.     case SCORE:
  23.     case FOO:
  24.     case BRIEF:
  25.     case SUSPEND:
  26.     case HOURS:
  27.     case LOG:
  28.         actspk(verb);
  29.         break;
  30.     case TAKE:
  31.         vtake();
  32.         break;
  33.     case DROP:
  34.         vdrop();
  35.         break;
  36.     case OPEN:
  37.     case LOCK:
  38.         vopen();
  39.         break;
  40.     case SAY:
  41.         vsay();
  42.         break;
  43.     case NOTHING:
  44.         rspeak(54);
  45.         break;
  46.     case ON:
  47.         von();
  48.         break;
  49.     case OFF:
  50.         voff();
  51.         break;
  52.     case WAVE:
  53.         vwave();
  54.         break;
  55.     case KILL:
  56.         vkill();
  57.         break;
  58.     case POUR:
  59.         vpour();
  60.         break;
  61.     case EAT:
  62.         veat();
  63.         break;
  64.     case DRINK:
  65.         vdrink();
  66.         break;
  67.     case RUB:
  68.         if (object != LAMP)
  69.             rspeak(76);
  70.         else
  71.             actspk(RUB);
  72.         break;
  73.     case THROW:
  74.         vthrow();
  75.         break;
  76.     case FEED:
  77.         vfeed();
  78.         break;
  79.     case FIND:
  80.     case INVENTORY:
  81.         vfind();
  82.         break;
  83.     case FILL:
  84.         vfill();
  85.         break;
  86.     case READ:
  87.         vread();
  88.         break;
  89.     case BLAST:
  90.         vblast();
  91.         break;
  92.     case BREAK:
  93.         vbreak();
  94.         break;
  95.     case WAKE:
  96.         vwake();
  97.         break;
  98.     default:
  99.         printf("This verb is not implemented yet.\n");
  100.     }
  101. }
  102.  
  103. /*
  104.     CARRY TAKE etc.
  105. */
  106. vtake()
  107. {
  108.     char msg;
  109.     int i;
  110.  
  111.     if (toting(object)) {
  112.         actspk(verb);
  113.         return;
  114.     }
  115.     /*
  116.        special case objects and fixed objects
  117.     */
  118.     msg = 25;
  119.     if (object == PLANT && prop[PLANT] <= 0)
  120.         msg = 115;
  121.     if (object == BEAR && prop[BEAR] == 1)
  122.         msg = 169;
  123.     if (object == CHAIN && prop[BEAR] != 0)
  124.         msg = 170;
  125.     if (fixed[object]) {
  126.         rspeak(msg);
  127.         return;
  128.     }
  129.     /*
  130.        special case for liquids
  131.     */
  132.     if (object == WATER || object == OIL) {
  133.         if (!here(BOTTLE) || liq() != object) {
  134.             object = BOTTLE;
  135.             if (toting(BOTTLE)&&prop[BOTTLE] == 1){
  136.                 vfill();
  137.                 return;
  138.             }
  139.             if (prop[BOTTLE] != 1)
  140.                 msg = 105;
  141.             if (!toting(BOTTLE))
  142.                 msg = 104;
  143.             rspeak(msg);
  144.             return;
  145.         }
  146.         object = BOTTLE;
  147.     }
  148.     if (holding >= 7) {
  149.         rspeak(92);
  150.         return;
  151.     }
  152.     /*
  153.        special case for bird.
  154.     */
  155.     if (object == BIRD && prop[BIRD] == 0) {
  156.         if (toting(ROD)) {
  157.             rspeak(26);
  158.             return;
  159.         }
  160.         if (!toting(CAGE)) {
  161.             rspeak(27);
  162.             return;
  163.         }
  164.         prop[BIRD] = 1;
  165.     }
  166.     if ( (object == BIRD || object == CAGE) &&
  167.         prop[BIRD] != 0)
  168.         carry((BIRD+CAGE)-object,loc);
  169.     carry(object,loc);
  170.     /*
  171.        handle liquid in bottle
  172.     */
  173.     i = liq();
  174.     if (object == BOTTLE && i != 0)
  175.         place[i] = -1;
  176.     rspeak(54);
  177. }
  178.  
  179. /*
  180.     DROP etc.
  181. */
  182. vdrop()
  183. {
  184.     int i;
  185.  
  186.     /*
  187.        check for dynamite
  188.     */
  189.     if (toting(ROD2) && object == ROD && !toting(ROD))
  190.         object = ROD2;
  191.     if (!toting(object)){
  192.         actspk(verb);
  193.         return;
  194.     }
  195.     /*
  196.        snake and bird
  197.     */
  198.     if (object == BIRD && here(SNAKE)) {
  199.         rspeak(30);
  200.         if (closed)
  201.             dwarfend();
  202.         dstroy(SNAKE);
  203.         prop[SNAKE] = -1;
  204.     }
  205.     /*
  206.        coins and vending machine
  207.     */
  208.     else if (object == COINS && here(VEND)) {
  209.         dstroy(COINS);
  210.         drop(BATTERIES,loc);
  211.         pspeak(BATTERIES,0);
  212.         return;
  213.     }
  214.     /*
  215.        bird and dragon (ouch!!)
  216.     */
  217.     else if (object == BIRD && at(DRAGON) && prop[DRAGON] == 0){
  218.         rspeak(154);
  219.         dstroy(BIRD);
  220.         prop[BIRD] = 0;
  221.         if (place[SNAKE] != 0)
  222.             ++tally2;
  223.         return;
  224.     }
  225.     /*
  226.        Bear and troll
  227.     */
  228.     if (object == BEAR && at(TROLL)) {
  229.         rspeak(163);
  230.         move(TROLL,0);
  231.         move((TROLL+MAXOBJ),0);
  232.         move(TROLL2,117);
  233.         move((TROLL2+MAXOBJ),122);
  234.         juggle(CHASM);
  235.         prop[TROLL] = 2;
  236.     }
  237.     /*
  238.        vase
  239.     */
  240.     else if (object == VASE) {
  241.         if (loc == 96)
  242.             rspeak(54);
  243.         else {
  244.             prop[VASE] = at(PILLOW) ? 0 : 2;
  245.             pspeak(VASE,prop[VASE]+1);
  246.             if (prop[VASE] != 0)
  247.                 fixed[VASE] = -1;
  248.         }
  249.     }
  250.     /*
  251.        handle liquid and bottle
  252.     */
  253.     i = liq();
  254.     if (i == object)
  255.         object = BOTTLE;
  256.     if (object == BOTTLE && i != 0)
  257.         place[i] = 0;
  258.     /*
  259.        handle bird and cage
  260.     */
  261.     if (object == CAGE && prop[BIRD] != 0)
  262.         drop(BIRD,loc);
  263.     if (object == BIRD)
  264.         prop[BIRD] = 0;
  265.     drop(object,loc);
  266. }
  267.  
  268. /*
  269.     LOCK, UNLOCK, OPEN, CLOSE etc.
  270. */
  271. vopen()
  272. {
  273.     char msg,oyclam;
  274.  
  275.     switch(object) {
  276.     case CLAM:
  277.     case OYSTER:
  278.         oyclam = (object == OYSTER ? 1 : 0);
  279.         if (verb == LOCK)
  280.             msg = 61;
  281.         else if (!toting(TRIDENT))
  282.             msg = 122+oyclam;
  283.         else if (toting(object))
  284.             msg = 120+oyclam;
  285.         else {
  286.             msg = 124+oyclam;
  287.             dstroy(CLAM);
  288.             drop(OYSTER,loc);
  289.             drop(PEARL,105);
  290.         }
  291.         break;
  292.     case DOOR:
  293.         msg = (prop[DOOR] == 1 ? 54 : 111);
  294.         break;
  295.     case CAGE:
  296.         msg = 32;
  297.         break;
  298.     case KEYS:
  299.         msg = 55;
  300.         break;
  301.     case CHAIN:
  302.         if (!here(KEYS))
  303.             msg = 31;
  304.         else if (verb == LOCK) {
  305.             if (prop[CHAIN] != 0)
  306.                 msg = 34;
  307.             else if (loc != 130)
  308.                 msg = 173;
  309.             else {
  310.                 prop[CHAIN] = 2;
  311.                 if (toting(CHAIN))
  312.                     drop(CHAIN,loc);
  313.                 fixed[CHAIN] =  -1;
  314.                 msg = 172;
  315.             }
  316.         }
  317.         else {
  318.             if (prop[BEAR] == 0)
  319.                 msg = 41;
  320.             else if (prop[CHAIN] == 0)
  321.                 msg = 37;
  322.             else {
  323.                 prop[CHAIN] = 0;
  324.                 fixed[CHAIN] = 0;
  325.                 if (prop[BEAR] != 3)
  326.                     prop[BEAR] = 2;
  327.                 fixed[BEAR] = 2-prop[BEAR];
  328.                 msg = 171;
  329.             }
  330.         }
  331.         break;
  332.     case GRATE:
  333.         if (!here(KEYS))
  334.             msg = 31;
  335.         else if (closing) {
  336.             if (!panic) {
  337.                 clock2 = 15;
  338.                 ++panic;
  339.             }
  340.             msg = 130;
  341.         }
  342.         else {
  343.             msg = 34+prop[GRATE];
  344.             prop[GRATE] = (verb == LOCK ? 0 : 1);
  345.             msg += 2*prop[GRATE];
  346.         }
  347.         break;
  348.     default:
  349.         msg = 33;
  350.     }
  351.     rspeak(msg);
  352. }
  353.  
  354. /*
  355.     SAY etc.
  356. */
  357. vsay()
  358. {
  359.     int wtype,wval;
  360.  
  361.     analyze(word1,&wtype,&wval);
  362.     printf("Okay.\n%s\n",wval == SAY ? word2 : word1);
  363. }
  364.  
  365. /*
  366.     ON etc.
  367. */
  368. von()
  369. {
  370.     if (!here(LAMP))
  371.         actspk(verb);
  372.     else if (limit<0)
  373.         rspeak(184);
  374.     else {
  375.         prop[LAMP] = 1;
  376.         rspeak(39);
  377.         if (wzdark) {
  378.             wzdark = 0;
  379.             describe();
  380.         }
  381.     }
  382. }
  383.  
  384. /*
  385.     OFF etc.
  386. */
  387. voff()
  388. {
  389.     if (!here(LAMP))
  390.         actspk(verb);
  391.     else {
  392.         prop[LAMP] = 0;
  393.         rspeak(40);
  394.     }
  395. }
  396.  
  397. /*
  398.     WAVE etc.
  399. */
  400. vwave()
  401. {
  402.     if (!toting(object) &&
  403.        (object != ROD || !toting(ROD2)))
  404.         rspeak(29);
  405.     else if (object != ROD || !at(FISSURE) ||
  406.         !toting(object) || closing)
  407.         actspk(verb);
  408.     else {
  409.         prop[FISSURE] = 1-prop[FISSURE];
  410.         pspeak(FISSURE,2-prop[FISSURE]);
  411.     }
  412. }
  413.  
  414. /*
  415.     ATTACK, KILL etc.
  416. */
  417. vkill()
  418. {
  419.     char msg;
  420.     int i;
  421.  
  422.     switch(object) {
  423.     case BIRD:
  424.         if (closed)
  425.             msg = 137;
  426.         else {
  427.             dstroy(BIRD);
  428.             prop[BIRD] = 0;
  429.             if (place[SNAKE] == 19)
  430.                 ++tally2;
  431.             msg = 45;
  432.         }
  433.         break;
  434.     case 0:
  435.         msg = 44;
  436.         break;
  437.     case CLAM:
  438.     case OYSTER:
  439.         msg = 150;
  440.         break;
  441.     case SNAKE:
  442.         msg = 46;
  443.         break;
  444.     case DWARF:
  445.         if (closed)
  446.             dwarfend();
  447.         msg = 49;
  448.         break;
  449.     case TROLL:
  450.         msg = 157;
  451.         break;
  452.     case BEAR:
  453.         msg = 165+(prop[BEAR]+1)/2;
  454.         break;
  455.     case DRAGON:
  456.         if (prop[DRAGON] != 0) {
  457.             msg = 167;
  458.             break;
  459.         }
  460.         if (!yes(49,0,0))
  461.             break;
  462.         pspeak(DRAGON,1);
  463.         prop[DRAGON] = 2;
  464.         prop[RUG] = 0;
  465.         move((DRAGON+MAXOBJ),-1);
  466.         move((RUG+MAXOBJ),0);
  467.         move(DRAGON,120);
  468.         move(RUG,120);
  469.         for(i = 1;i<MAXOBJ;++i)
  470.             if (place[i] == 119 || place[i] == 121)
  471.                 move(i,120);
  472.         newloc = 120;
  473.         return;
  474.     default:
  475.         actspk(verb);
  476.         return;
  477.     }
  478.     rspeak(msg);
  479. }
  480.  
  481. /*
  482.     POUR
  483. */
  484. vpour()
  485. {
  486.     if (object == BOTTLE || object == 0)
  487.         object = liq(0);
  488.     if (object == 0) {
  489.         needobj();
  490.         return;
  491.     }
  492.     if (!toting(object)) {
  493.         actspk(verb);
  494.         return;
  495.     }
  496.     if (object != OIL && object != WATER) {
  497.         rspeak(78);
  498.         return;
  499.     }
  500.     prop[BOTTLE] = 1;
  501.     place[object] = 0;
  502.     if (at(PLANT)) {
  503.         if (object != WATER)
  504.             rspeak(112);
  505.         else {
  506.             pspeak(PLANT,prop[PLANT]+1);
  507.             prop[PLANT] = (prop[PLANT]+2)%6;
  508.             prop[PLANT2] = prop[PLANT]/2;
  509.             describe();
  510.         }
  511.     }
  512.     else if (at(DOOR)) {
  513.         prop[DOOR] = (object == OIL ? 1 : 0);
  514.         rspeak(113+prop[DOOR]);
  515.     }
  516.     else
  517.         rspeak(77);
  518. }
  519.  
  520. /*
  521.     EAT
  522. */
  523. veat()
  524. {
  525.     char msg;
  526.  
  527.     switch(object) {
  528.     case FOOD:
  529.         dstroy(FOOD);
  530.         msg = 72;
  531.         break;
  532.     case BIRD: case SNAKE: case CLAM: case OYSTER:
  533.     case DWARF: case DRAGON: case TROLL: case BEAR:
  534.         msg = 71;
  535.         break;
  536.     default:
  537.         actspk(verb);
  538.         return;
  539.     }
  540.     rspeak(msg);
  541. }
  542.  
  543. /*
  544.     DRINK
  545. */
  546. vdrink()
  547. {
  548.     if (object != WATER)
  549.         rspeak(110);
  550.     else if (liq() != WATER || !here(BOTTLE))
  551.         actspk(verb);
  552.     else {
  553.         prop[BOTTLE] = 1;
  554.         place[WATER] = 0;
  555.         rspeak(74);
  556.     }
  557. }
  558.  
  559. /*
  560.     THROW etc.
  561. */
  562. vthrow()
  563. {
  564.     char msg;
  565.     int i;
  566.  
  567.     if (toting(ROD2) && object == ROD && !toting(ROD))
  568.         object = ROD2;
  569.     if (!toting(object)) {
  570.         actspk(verb);
  571.         return;
  572.     }
  573.     /*
  574.        treasure to troll
  575.     */
  576.     if (at(TROLL) && object >= 50 && object<MAXOBJ) {
  577.         rspeak(159);
  578.         drop(object,0);
  579.         move(TROLL,0);
  580.         move((TROLL+MAXOBJ),0);
  581.         drop(TROLL2,117);
  582.         drop((TROLL2+MAXOBJ),122);
  583.         juggle(CHASM);
  584.         return;
  585.     }
  586.     /*
  587.        feed the bears...
  588.     */
  589.     if (object == FOOD && here(BEAR)) {
  590.         object = BEAR;
  591.         vfeed();
  592.         return;
  593.     }
  594.     /*
  595.        if not axe, same as drop...
  596.     */
  597.     if (object != AXE) {
  598.         vdrop();
  599.         return;
  600.     }
  601.     /*
  602.        AXE is THROWN
  603.     */
  604.     /*
  605.        at a dwarf...
  606.     */
  607.     if (i = dcheck()) {
  608.         msg = 48;
  609.         if (pct(33)) {
  610.             dseen[i] = dloc[i] = 0;
  611.             msg = 47;
  612.             ++dkill;
  613.             if (dkill == 1)
  614.                 msg = 149;
  615.         }
  616.     }
  617.     /*
  618.        at a dragon...
  619.     */
  620.     else if (at(DRAGON) && prop[DRAGON] == 0) 
  621.         msg = 152;
  622.     /*
  623.        at the troll...
  624.     */
  625.     else if (at(TROLL))
  626.         msg = 158;
  627.     /*
  628.        at the bear...
  629.     */
  630.     else if (here(BEAR) && prop[BEAR] == 0) {
  631.         rspeak(164);
  632.         drop(AXE,loc);
  633.         fixed[AXE] = -1;
  634.         prop[AXE] = 1;
  635.         juggle(BEAR);
  636.         return;
  637.     }
  638.     /*
  639.        otherwise it is an attack
  640.     */
  641.     else {
  642.         verb = KILL;
  643.         object = 0;
  644.         itverb();
  645.         return;
  646.     }
  647.     /*
  648.        handle the left over axe...
  649.     */
  650.     rspeak(msg);
  651.     drop(AXE,loc);
  652.     describe();
  653. }
  654.  
  655. /*
  656.     INVENTORY, FIND etc.
  657. */
  658. vfind()
  659. {
  660.     char msg;
  661.     if (toting(object))
  662.         msg = 24;
  663.     else if (closed)
  664.         msg = 138;
  665.     else if (dcheck() && dflag >= 2 && object == DWARF)
  666.         msg = 94;
  667.     else if (at(object) ||
  668.         (liq() == object && here(BOTTLE)) ||
  669.         object == liqloc(loc))
  670.         msg = 94;
  671.     else {
  672.         actspk(verb);
  673.         return;
  674.     }
  675.     rspeak(msg);
  676. }
  677.  
  678. /*
  679.     FILL
  680. */
  681. vfill()
  682. {
  683.     char msg;
  684.     int i;
  685.  
  686.     switch(object) {
  687.     case BOTTLE:
  688.         if (liq() != 0)
  689.             msg = 105;
  690.         else if (liqloc(loc) == 0)
  691.             msg = 106;
  692.         else {
  693.             prop[BOTTLE] = cond[loc] & WATOIL;
  694.             i = liq();
  695.             if (toting(BOTTLE))
  696.                 place[i] = -1;
  697.             msg = (i == OIL ? 108 : 107);
  698.         }
  699.         break;
  700.     case VASE:
  701.         if (liqloc(loc) == 0) {
  702.             msg = 144;
  703.             break;
  704.         }
  705.         if (!toting(VASE)) {
  706.             msg = 29;
  707.             break;
  708.         }
  709.         rspeak(145);
  710.         vdrop();
  711.         return;
  712.     default:
  713.         msg = 29;
  714.     }
  715.     rspeak(msg);
  716. }
  717.  
  718. /*
  719.     FEED
  720. */
  721. vfeed()
  722. {
  723.     char msg;
  724.  
  725.     switch(object) {
  726.     case BIRD:
  727.         msg = 100;
  728.         break;
  729.     case DWARF:
  730.         if (!here(FOOD)) {
  731.             actspk(verb);
  732.             return;
  733.         }
  734.         ++dflag;
  735.         msg = 103;
  736.         break;
  737.     case BEAR:
  738.         if (!here(FOOD)) {
  739.             if (prop[BEAR] == 0)
  740.                 msg = 102;
  741.             else if (prop[BEAR] == 3)
  742.                 msg = 110;
  743.             else {
  744.                 actspk(verb);
  745.                 return;
  746.             }
  747.         break;
  748.         }
  749.         dstroy(FOOD);
  750.         prop[BEAR] = 1;
  751.         fixed[AXE] = 0;
  752.         prop[AXE] = 0;
  753.         msg = 168;
  754.         break;
  755.     case DRAGON:
  756.         msg = (prop[DRAGON] != 0 ? 110 : 102);
  757.         break;
  758.     case TROLL:
  759.         msg = 182;
  760.         break;
  761.     case SNAKE:
  762.         if (closed || !here(BIRD)) {
  763.             msg = 102;
  764.             break;
  765.         }
  766.         msg = 101;
  767.         dstroy(BIRD);
  768.         prop[BIRD] = 0;
  769.         ++tally2;
  770.         break;
  771.     default:
  772.         msg = 14;
  773.     }
  774.     rspeak(msg);
  775. }
  776.  
  777. /*
  778.     READ etc.
  779. */
  780. vread()
  781. {
  782.     char msg;
  783.  
  784.     msg = 0;
  785.     if (dark()) {
  786.         printf("I see no %s here.\n",probj(object));
  787.         return;
  788.     }
  789.     switch(object) {
  790.     case MAGAZINE:
  791.         msg = 190;
  792.         break;
  793.     case TABLET:
  794.         msg = 196;
  795.         break;
  796.     case MESSAGE:
  797.         msg = 191;
  798.         break;
  799.     case OYSTER:
  800.         if (!toting(OYSTER) || !closed)
  801.             break;
  802.         yes(192,193,54);
  803.         return;
  804.     default:
  805.         ;
  806.     }
  807.     if (msg)
  808.         rspeak(msg);
  809.     else
  810.         actspk(verb);
  811. }
  812.  
  813. /*
  814.     BLAST etc.
  815. */
  816. vblast()
  817. {
  818.     if (prop[ROD2] < 0 || !closed)
  819.         actspk(verb);
  820.     else {
  821.         bonus = 133;
  822.         if (loc == 115)
  823.             bonus = 134;
  824.         if (here(ROD2))
  825.             bonus = 135;
  826.         rspeak(bonus);
  827.         normend();
  828.     }
  829. }
  830.  
  831. /*
  832.     BREAK etc.
  833. */
  834. vbreak()
  835. {
  836.     char msg;
  837.     if (object == MIRROR) {
  838.         msg = 148;
  839.         if (closed) {
  840.             rspeak(197);
  841.             dwarfend();
  842.         }
  843.     }
  844.     else if (object == VASE && prop[VASE] == 0) {
  845.         msg = 198;
  846.         if (toting(VASE))
  847.             drop(VASE,loc);
  848.         prop[VASE] = 2;
  849.         fixed[VASE] = -1;
  850.     }
  851.     else {
  852.         actspk(verb);
  853.         return;
  854.     }
  855.     rspeak(msg);
  856. }
  857.  
  858. /*
  859.     WAKE etc.
  860. */
  861. vwake()
  862. {
  863.     if (object != DWARF || !closed)
  864.         actspk(verb);
  865.     else {
  866.         rspeak(199);
  867.         dwarfend();
  868.     }
  869. }
  870.  
  871. /*
  872.     Routine to speak default verb message
  873. */
  874. actspk(verb)
  875. int verb;
  876. {
  877.     char i;
  878.  
  879.     if (verb<1 || verb>31)
  880.         bug(39);
  881.     i = actmsg[verb];
  882.     if (i)
  883.         rspeak(i);
  884. }
  885.  
  886. /*
  887.     Routine to indicate no reasonable
  888.     object for verb found.  Used mostly by
  889.     intransitive verbs.
  890. */
  891. needobj()
  892. {
  893.     int wtype,wval;
  894.  
  895.     analyze(word1,&wtype,&wval);
  896.     printf("%s what?\n",wtype == 2 ? word1 : word2);
  897. }
  898.  
  899.  
  900.  
  901.